package com.njts.interview;

public class Father {
    public int i = test();//3
    // j=5
    public static int j = method();// 1
    //static 关键字 :静态 (模板) 静态变量/类变量
    //       1.被该类的所有实例对象共享(模板变量)
    //         2.静态变量能通过类名.变量名直接使用,不用实例化
    //         3.静态变量可以被改类的实例化对象直接使用
    //         4 静态变量先于成员变量产生并赋值
    //            静态方法
    //         0.静态方法能使用静态变量,但静态方法不能使用成员变量->先后顺序 静态(类)先,成员(后) 后能用先
    //         1.静态方法能通过类名.方法名直接使用,不用实例化
    //         2.静态方法可以被该类的实例化对象直接使用
    //         3 静态方法先于成员方法产生

    // 对象初始化行为(顺序)
    //new Son()
    // 1. 加载父类信息,初始化静态变量,静态方法
    // 2   执行父类静态代码块
    // 3加载子类信息,初始化静态变量,静态方法
    // 4  执行子类静态代码块
    //,先有模板,再有实例
    //5. 初始化成员变量,成员方法
    // 6    实例化对象 执行构造代码块,声明父类构造函数
    // 7   执行父类的构造函数,生成父类实例
    // 8初始化子类成员变量,成员方法
    // 9   实例化子类对象,先有模板,再有实例 执行构造代码块,声明子类构造函数
    // 10 执行子类的构造函数,生成子类实例
    //          (先有父,后有子)

    static {
        System.out.println("(0)");//2
    }


    Father() {
        System.out.print("(2)"); //7
    }
    //构造代码块(开发几乎不用)
    {
        System.out.print("(3)"); // 6
    }

    public int test() {
        System.out.print("(4)");
        return 4;
    }

    public static int method() {
        System.out.print("(5)");
        return 5;
    }
}

class Son extends Father {
    // test方法执行两次:1为成员变量i赋值会被调用  2 创建子类的实例化对象之前会再次进行赋值操作
    public int i = test(); //5
    public static int j = method();//3

    static {
        System.out.print("(6)");//4
    }

    Son() {
        System.out.print("(7)");// 10
    }

    {
        System.out.print("(8)");// 9
    }

    public int test() {
        {
            System.out.println(1111);
        }
        System.out.print("(9)");// 8
        return 9;
    }

    public static int method() {
        System.out.print("(10)");
        return 10;
    }

    public static void main(String[] args) {
        // new了一个Son对象
        Son s1 = new Son();//第一次
        System.out.println();
        // new了一个Son对象
        Son s2 = new Son();//第二次执行时,不需要重复加载类的信息,直接走实例化流程
    }
}
